prompt1="这是一个ACM的编程题，现在请你先复述一遍题目和测试数据，按题目原本的描述进行描述，然后在进行python编程解答"
#必须选择gpt-5作为model。如果没改对，告诉他示例没有完全通过

prompt2="""
示例没有完全通过，输入输出改写成
n = input()      #指定为N个数，输入,表示第一行的输入
lst = []         #指定一个空列表
for i in range(int(n)):        #循环N次
    lst.append(int(input()))      #不断的调用接下来行的输入

"""

"""
题目复述
在无线网络优化中，基站的空间分布会影响信号覆盖质量。给定若干现有基站的二维坐标与聚类个数 K，先用 K-means 将所有基站划分为 K 个簇，然后计算各簇的轮廓系数（Silhouette Coefficient）。认为轮廓系数越小的簇越“异常”（覆盖/布局问题越大），需要在该簇中心处新增一个基站。
请输出“需要新增基站的簇”的中心坐标，结果保留两位小数，采用银行家舍入（ROUND_HALF_EVEN）。
K-means 终止条件：最多迭代 100 次，或所有中心移动距离均小于 1e-6。
轮廓系数：
对于每个点 i：a(i) 为与同簇其它点的平均距离；b(i) 为与最近其他簇中所有点的平均距离；s(i) = (b(i) - a(i)) / max(a(i), b(i))。
簇的轮廓系数为簇内所有点的 s(i) 平均值；若簇内样本数 ≤ 1，则该簇轮廓系数记为 0。
输出坐标为 x,y，各保留两位小数，使用银行家舍入。
输入
第一行：n k（n 为基站数，k 为聚类数）
接下来 n 行：每行 x y（均为整数）
输出
一行：需要新增基站位置的坐标 x,y（两位小数，ROUND_HALF_EVEN

可以使用newcoder和codefun来去验证代码有没有通过
https://codefun2000.com/p/P3791

很奇怪的点，虽然示例都通过了，但是ac确是0%，非常奇怪，
"""

# 核心解法----本解法没ac
# 排序 - 按x+y排序
# 贪心分组 - 按间隙或均分
# 贪心选择 - 选最分散的

import sys
import math
from decimal import Decimal, ROUND_HALF_EVEN

def round_he(x):
    return Decimal(x).quantize(Decimal("0.00"), rounding=ROUND_HALF_EVEN)

def read_input():
    data = sys.stdin.read().strip().split()
    if not data:
        return 0, 0, []
    it = iter(data)
    n = int(next(it)); k = int(next(it))
    pts = [(float(next(it)), float(next(it))) for _ in range(n)]
    return n, k, pts

def avg_center(points, idxs):
    m = len(idxs)
    sx = sum(points[i][0] for i in idxs) / m
    sy = sum(points[i][1] for i in idxs) / m
    return (sx, sy)

def avg_radius(points, idxs, c):
    if not idxs:
        return 0.0
    cx, cy = c
    s = 0.0
    for i in idxs:
        dx = points[i][0] - cx
        dy = points[i][1] - cy
        s += math.hypot(dx, dy)
    return s / len(idxs)

def balanced_groups(order, k):
    n = len(order)
    base = n // k
    rem = n % k
    groups = []
    start = 0
    for t in range(k):
        size = base + (1 if t < rem else 0)
        end = start + size
        groups.append(order[start:end])
        start = end
    return groups

def split_by_gaps(order, svals, k):
    n = len(order)
    if k == 1:
        return [order[:]]
    if k == 2:
        if n <= 2:
            return [order[:1], order[1:]]
        gaps = []
        for i in range(n - 1):
            gaps.append((svals[i+1] - svals[i], i))  # gap, split after i
        gaps_sorted = sorted(gaps, reverse=True)
        g1, i1 = gaps_sorted[0]
        g2 = gaps_sorted[1][0] if len(gaps_sorted) > 1 else 0.0
        # 显著离群：在最大间隙处切，否则均分
        if g1 >= 2.0 * g2:   #贪心分组（局部最优）
            cut = i1 + 1
            return [order[:cut], order[cut:]]
        else:
            return balanced_groups(order, 2)
    # k>2：若显著离群则取最大k-1间隙切，否则均分
    gaps = []
    for i in range(n - 1):
        gaps.append((svals[i+1] - svals[i], i))
    gaps_sorted = sorted(gaps, reverse=True)
    if len(gaps_sorted) >= k-1 and (k == 2 or (gaps_sorted[0][0] >= 2.0 * (gaps_sorted[1][0] if len(gaps_sorted) > 1 else 0.0))):
        cuts = sorted([idx for _, idx in gaps_sorted[:k-1]])
        groups = []
        prev = 0
        for idx in cuts:
            groups.append(order[prev:idx+1])
            prev = idx + 1
        groups.append(order[prev:])
        return groups
    else:
        return balanced_groups(order, k)

def main():
    n, k, pts = read_input()
    if n == 0 or k == 0:
        print("0.00,0.00")
        return
    k = min(k, n)

    # 按 x+y、x、y 排序，连续切分
    order = sorted(range(n), key=lambda i: (pts[i][0] + pts[i][1], pts[i][0], pts[i][1]))
    svals = [pts[i][0] + pts[i][1] for i in order]

    groups = split_by_gaps(order, svals, k)

    # 计算每簇质心与平均半径，选择平均半径更大的簇
    centers = []
    spreads = []
    for g in groups:
        c = avg_center(pts, g)
        centers.append(c)
        spreads.append(avg_radius(pts, g, c))

    best = max(range(len(groups)), key=lambda i: spreads[i])  #贪心选择（全局最优）
    cx, cy = centers[best]
    print(f"{round_he(cx)},{round_he(cy)}")

if __name__ == "__main__":
    main()



"""
示例一：
6 2
0 0
1 1 
2 2 
10 10
11 11 
5 5

预期输出：
8.67,8.67

"""

"""
示例二：
4 2
0 0
0 1
1 0
10 10

预期输出：
0.33 0.33

"""